// function promiseMiddleware(store)
// {
//   var dispatch=store.dispatch
//   return function (next)
//   {
//     return function (action)
//     {
//       if(Object.prototype.toString.call(action)==='[object Promise]')
//       {
//         return action.then(dispatch)
//       }
//       if(Object.prototype.toString.call(action.payload)==='[object Promise]')
//       {
//         return action.payload.then(res=>{
//           dispatch({
//             type:action.type,
//             payload:res
//           })
//         })
//       }
//       return next(action)
//     }
//   }
// }

// export default store

// dispatch({ type, payload })
// dispatch(new Promise())
// redux-promise原码
// applyMiddleware调用这个方法，传入当前的store
// 参数_ref 实际上是applyMiddleware在执行时传入的当前store对象
function promiseMiddleware(store) {
  // dispatch其实就是createStore创建的store对象中的dispatch方法，为了方便将接收到的非标准action处理成标准的action对象后重新派发给store
  var dispatch = store.dispatch
  // 返回一个闭包函数，这个闭包函数里可以随时调用dispatch方法
  // 当redux被实例化时，调用这个函数，同时将当前被注册的中间件中的下一个函数传给这个函数；next代表是中间件队列中的下一个中间件，如果下一个中间件不存在的话，就直接调用dispatch
  return function (next) {
    // 这个函数被返回后就注入store的中间件队列里，后续我们每一次调用dispatch都会递归调用当前队列中的所有中间件对action进行匹配和处理。
    return function (action) {
      // 判断当前接收到的action对象是否是一个Promise对象
      // 如果是一个promise对象，为这个promise对象添加一个新的成功处理函数（.then）
      if (Object.prototype.toString.call(action) === '[object Promise]') {
        // 直接通过dispatch将promise获取到的结果返回给了store
        return action.then(dispatch)
      }

      // 判断action.payload是否是一个promise对象
      if (
        Object.prototype.toString.call(action.payload) === '[object Promise]'
      ) {
        // 通过.then方法传入一个回调函数，然后在回调函数里重新构建一个全新的标准action对象
        return action.payload.then(res => {
          dispatch({
            type: action.type,
            payload: res,
          })
        })
      }
      // 不是promise对象，action.payload也不是promise对象，就丢给下一个中间件处理
      return next(action)
    }
  }
}

// 要求实现一个中间件，让redux的dispatch可以接受一个函数作为参数，而且将函数的计算结果存入到redux里
